// 题目描述
// 给你一个整数数组 nums 和一个整数 k 。

// 每一步操作中，你需要从数组中选出和为 k 的两个整数，并将它们移出数组。

// 返回你可以对数组执行的最大操作数。



// 示例 1：

// 输入：nums = [1,2,3,4], k = 5
// 输出：2
// 解释：开始时 nums = [1,2,3,4]：
// - 移出 1 和 4 ，之后 nums = [2,3]
// - 移出 2 和 3 ，之后 nums = []
// 不再有和为 5 的数对，因此最多执行 2 次操作。
// 示例 2：

// 输入：nums = [3,1,3,4,3], k = 6
// 输出：1
// 解释：开始时 nums = [3,1,3,4,3]：
// - 移出前两个 3 ，之后nums = [1,4,3]
// 不再有和为 6 的数对，因此最多执行 1 次操作。

// 自己的答案(模仿“盛最多水容器”双指针，错误)：

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var maxOperations = function (nums, k) {
    // let j = 0; 

    // for (let i = 0; i < nums.length; i++) {
    //     if(nums[i] + nums[j] === k) {

    //     } else {
    //         j++;
    //     }
    // }

    let left = 0;
    let right = nums.length - 1;
    let count = 0;
    while (left < right) {
        if(nums[left] + nums[right] === k) {
            nums.splice(right, 1);
            nums.splice(left, 1);
            ++count;
            continue;
        }
        // 移动指针
        if (nums[left] < nums[right]) {
            left++;
        } else {
            right--;
        }
    }
    console.log(nums)
    return count
};

console.log(maxOperations([1,2,3,4], 5))

// Gpt解法：
function maxOperations(nums, k) {
    const numMap = new Map();
    let count = 0;
 
    for (let num of nums) {
        const complement = k - num;
        if (numMap.has(complement)) {
            count++;
            numMap.delete(complement); // 移除已经使用过的元素
        } else {
            numMap.set(num, (numMap.get(num) || 0) + 1);
        }
    }
 
    return count;
}
 
// 示例测试
console.log(maxOperations([1, 2, 3, 4], 5)); // 输出: 2
console.log(maxOperations([3, 1, 3, 4, 3], 6)); // 输出: 1

// 官方题解：
// 判断是否存在 k-nums[i]
var maxOperations = function (nums, k) {
    let bucket = [];
    let time = 0;
    for (let i = 0; i < nums.length; i++) {
        if(bucket[k-nums[i]]){ // 若 bucket[k-nums[i]] = 0，则返回 false，移除已经使用过的元素。目的就是为了这种情况，k = 5  [2, 3, 2]（匹配到 3 后把第一个 2 的值置为零，这样当循环到第三个 2 的时候就不会匹配第一个判断条件，而是让其加 1 等到下一个出现跟他相加能等于 k 的项）
            bucket[k-nums[i]]--;
            time++;
        }else{
            bucket[nums[i]] = bucket[nums[i]] ? bucket[nums[i]] + 1 : 1;
        }
    }
    return time;
};

//双指针
var maxOperations = function (nums, k) {
    let time = 0;
    nums.sort((a,b)=>a-b);
    let i = 0;
    let j = nums.length-1;
    while(i < j){
        if(nums[i] + nums[j] < k){
            i++;
        }else if(nums[i] + nums[j] > k){
            j--;
        }else{
            time++,i++,j--;
        }
    }
    return time;
};